Migrated MariaDB, MySQL, PostgreSQL tests to use testcontainers to simplify local setup - #2011

🟡 Not ready to approve

It currently introduces a dependency-resolution issue in the version catalog and a Kotlin compilation error from an unused import.

Once you've addressed the issues Copilot identified, you can request another Copilot review.

This review doesn't count toward merge requirements. Sign up for the private preview to control whether Copilot approvals count.

We're testing this review assessment. Please use 👍 or 👎 to tell us if it's correct.

Include in the Readme.md information and links about requirement to set up the Docker env for test conteainers with minimum technical requirements for 3 OS or link to that

• describe the idea of test separation (it's complicated)

`## :dataframe-jdbc

This module, published as dataframe-jdbc, contains all logic and tests for DataFrame to be able to work with
JDBC data sources.

See Read from SQL databases for more information
about how to use it.

Testing

The JDBC tests are split into three tiers by how they obtain a database. This keeps the default build
fast and dependency-free, while still allowing full coverage against real database engines.

1. H2 tests (default suite)

These run against an in-memory H2 database using its compatibility modes
(MODE=PostgreSQL, MODE=MySQL, MODE=MariaDB, MODE=MSSQLServer, etc.). They need no Docker and no external
server, so they are part of the regular test task and run in CI on every build.

Location: src/test/kotlin/.../io/h2/ (e.g. PostgresH2Test, MysqlH2Test, MariadbH2Test, MssqlH2Test).
Together with the SQLite/DuckDB tests they form the baseline coverage that always runs.

./gradlew :dataframe-jdbc:test

2. Testcontainers tests (real DB engines via Docker)

These spin up real PostgreSQL, MySQL, and MariaDB engines in Docker using
Testcontainers. They give the highest-fidelity coverage but require a running
Docker daemon, so they are excluded from the default test task and run under a dedicated Gradle task.

Location: src/test/kotlin/.../io/testcontainers/ (package org.jetbrains.kotlinx.dataframe.io.testcontainers).
The container image tags are configured in build.gradle.kts via BuildConfig
(POSTGRES_IMAGE, MYSQL_IMAGE, MARIADB_IMAGE).

Requirements: a running Docker daemon.

./gradlew :dataframe-jdbc:testcontainersTest

3. Local DB tests (servers on localhost)

These connect to database servers you run yourself on localhost (e.g. Postgres on 5432, MySQL, MariaDB, MSSQL).
They are meant for local, manual verification against a specific server and are excluded from the default
test task.

Location: src/test/kotlin/.../io/local/. Only classes whose names end with LocalTest
(PostgresLocalTest, MySqlLocalTest, MariadbLocalTest, PostgresConnectionUrlLocalTest) are picked up by the
dedicated task. The connection URLs/credentials are hardcoded in each test class, so start a matching server
before running them.

./gradlew :dataframe-jdbc:localDbTest

How the exclusions are wired

The default test task explicitly excludes both the Testcontainers and local-DB tests, and each is exposed as its
own task (see build.gradle.kts):

private val testcontainersTests = "org.jetbrains.kotlinx.dataframe.io.testcontainers.*"
private val localDbTests = "org.jetbrains.kotlinx.dataframe.io.local.*LocalTest"

tasks.test {
    filter {
        excludeTestsMatching(testcontainersTests)
        excludeTestsMatching(localDbTests)
    }
}

tasks.register<Test>("testcontainersTest") { /* includeTestsMatching(testcontainersTests) */ }
tasks.register<Test>("localDbTest")        { /* includeTestsMatching(localDbTests) */ }

So: H2 (and SQLite/DuckDB) run by default; Testcontainers and local-DB tests are opt-in via their own tasks.`